package cn.itsource.hrm.service.impl;

import cn.itsource.hrm.constants.RedisKeyConstants;
import cn.itsource.hrm.domain.Course;
import cn.itsource.hrm.domain.CourseType;
import cn.itsource.hrm.feignclients.PageStaticFeignClient;
import cn.itsource.hrm.feignclients.RedisFeignClient;
import cn.itsource.hrm.mapper.CourseTypeMapper;
import cn.itsource.hrm.service.ICourseTypeService;
import cn.itsource.hrm.util.AjaxResult;
import cn.itsource.hrm.vo.CrumbsVO;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import javafx.scene.Parent;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.io.Serializable;
import java.util.*;

/**
 * <p>
 * 课程目录 服务实现类
 * </p>
 *
 * @author luobiao
 * @since 2020-02-17
 */
@Service
public class CourseTypeServiceImpl extends ServiceImpl<CourseTypeMapper, CourseType> implements ICourseTypeService {

    @Autowired
    private RedisFeignClient redisFeignClient;

    @Autowired
    private PageStaticFeignClient pageStaticFeignClient;

    //抽取的重置redis的方法
    private List<CourseType> resetRedisforCourseType(){
        //数据库中查找所有课程类型
        List<CourseType> courseTypes = baseMapper.selectList(null);
        //查找到数据之后，同步一份到redis中
        redisFeignClient.set(RedisKeyConstants.COURSE_TYPE, JSON.toJSONString(courseTypes));
        return courseTypes;
    }

    @Override
    public boolean insert(CourseType entity) {

        boolean insertSuccess = super.insert(entity);

        //添加数据后重置redis
        //从数据库查询最新数据放入redis中
        resetRedisforCourseType();

        //触发课程首页的页面静态化
        this.triggerpageStatic();

        return insertSuccess;
    }

    @Override
    public boolean deleteById(Serializable id) {

        boolean deleteSuccess = super.deleteById(id);

        //添加数据后重置redis
        //从数据库查询最新数据放入redis中
        resetRedisforCourseType();

        //触发课程首页的页面静态化
        this.triggerpageStatic();

        return deleteSuccess;
    }

    @Override
    public boolean updateById(CourseType entity) {
        boolean updateSuccess = super.updateById(entity);

        //添加数据后重置redis
        //从数据库查询最新数据放入redis中
        resetRedisforCourseType();

        //触发课程首页的页面静态化
        this.triggerpageStatic();

        return updateSuccess;
    }



    /*
    * 页面静态化触发方法
    * */
    public void triggerpageStatic(){
        //1.将页面需要的数据存储到redis中 treeData
        List<CourseType> courseTypes = this.treeData();

        //2.参数：t_page表中的name(站点名字)和redis中的数据
        String pageName = "home";

        //封装数据的map
        Map<String,Object> model = new HashMap<>();
        model.put("courseTypes",courseTypes);

        AjaxResult ajaxResult = redisFeignClient.set(RedisKeyConstants.COURSE_TYPES_PAGE_STATIC, JSON.toJSONString(model));
        if(!ajaxResult.isSuccess()){
            throw new RuntimeException("页面静态化数据准备失败！！！"+ajaxResult.getMessage());
        }


        //3.课程微服务通过feign调用页面静态化微服务，触发页面静态化
        AjaxResult ajaxResultPageStatic = pageStaticFeignClient.pageStatic(pageName, RedisKeyConstants.COURSE_TYPES_PAGE_STATIC);
        if(!ajaxResultPageStatic.isSuccess()){
            throw new RuntimeException("页面静态化失败"+ajaxResultPageStatic.getMessage());
        }
    }

    @Override
    public List<CourseType> treeData() {
        //查询出所有课程类型
        List<CourseType> courseTypes = null;
        //查询课程分类前先查询redis
        AjaxResult ajaxResult = redisFeignClient.get(RedisKeyConstants.COURSE_TYPE);
        //判断redis中是否能拿到数据
        if(ajaxResult.isSuccess()&& ajaxResult.getResultObj()!=null){
            //说明redis中有数据
            //直接返回数据
            String jsonFromRedis = ajaxResult.getResultObj().toString();
            //需要将json字符串格式对象转为List
            courseTypes =  JSON.parseArray(jsonFromRedis,CourseType.class);

        }else{
            //说明redis中没有数据，需要到数据库中查找
            //查找到数据之后，同步一份到redis中
            courseTypes = resetRedisforCourseType();
        }

        //用来封装一级分类的集合，
        List<CourseType> PrimaryCourseTypes = new ArrayList<>();
        //找出所有一级分类
        for (CourseType courseType : courseTypes) {
            if(courseType.getPid().longValue()==0){
                PrimaryCourseTypes.add(courseType);
            }else{
                //不是一级分类的
                //定义当前分类的父分类容器
                CourseType CurrentParentCourseType = null;
                for (CourseType pcourseType : courseTypes) {
                    if(courseType.getPid().longValue()==pcourseType.getId()){
                        CurrentParentCourseType = pcourseType;
                        break;
                    }

                }
                if(CurrentParentCourseType!=null){
                    CurrentParentCourseType.getChildren().add(courseType);
                }
            }
        }
        return PrimaryCourseTypes;
    }

    //面包屑
    @Override
    public List<CrumbsVO> crumbs(Long id) {
        //1.根据课程分类查询所有父分类
        CourseType currentCourseType = baseMapper.selectById(id);
        //获取父级分类
        String path = currentCourseType.getPath();
        //去掉前面的 .
        path = path.startsWith(".")?path.substring(1):path;
        //去掉后面的 .
        path = path.endsWith(".")?path.substring(0,path.length()-1):path;
        //获取所有的父级分类
        String[] types = path.split("\\.");
        //结果
        List<CrumbsVO> result = new ArrayList<>();

        for (String type : types) {
            CrumbsVO crumbsVO = new CrumbsVO();
            //将type字符串转为Long
            Long typeId = Long.valueOf(type);
            CourseType courseType = baseMapper.selectById(typeId);
            //设置当前面包屑节点ownerProductType
            crumbsVO.setOwnerProductType(courseType);
            //获取当前节点的父id
            Long pid = courseType.getPid();
            //获取当前节点的所有同级，设置到OtherProductTypes
            List<CourseType> otherCoutseTypes = baseMapper.selectByPid(pid);
            //删除自己
            Iterator<CourseType> iterator = otherCoutseTypes.iterator();
            while (iterator.hasNext()){
                if(iterator.next().getId().equals(courseType.getId())){
                    iterator.remove();
                    break;
                }
            }
            //添加otherCoutseTypes属性
            crumbsVO.setOtherProductTypes(otherCoutseTypes);
            //添加到结果
            result.add(crumbsVO);
        }
        return result;
    }
}
